﻿@{
    Layout = null;
    string sexListJson = System.Text.Json.JsonSerializer.Serialize(
        ViewBag.SexList ?? new List<Model.WmsDictData>(),
        new System.Text.Json.JsonSerializerOptions
        {
            ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles,
            Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
        }
    );
    string stockInStatusListJson = System.Text.Json.JsonSerializer.Serialize(
        ViewBag.StockInStatusList ?? new List<Model.WmsDictData>(),
        new System.Text.Json.JsonSerializerOptions
        {
            ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles,
            Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
        }
    );
}

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8" />
    <title>进货订单</title>
    <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
    <link rel="stylesheet" href="//unpkg.com/element-plus/dist/index.css" />
    <script src="//unpkg.com/element-plus"></script>
    <script src="https://unpkg.com/element-plus/dist/locale/zh-cn.min.js"></script>
    <style>
        #tableBlock {
            margin: 0 auto;
            width: 1700px;
            padding-bottom:20px;
            box-shadow: 0 0 10px 4px rgba(0, 0, 0, 0.1);
            background-color:#fff;
        }

        #tableBlock label {
            font-size: 24px;
        }

        .formTableInput, .formTableSelect {
            display: inline-block;
            width: 180px;
        }

        .buttonBlock {
            height: 40px;
            width: 100%;
            padding-top: 10px;
            padding-left: 20px;
        }

        .pagination-container {
            margin-top: 20px;
            display: flex;
            justify-content: flex-end;
        }
        /* 模态框文本域样式优化 */
        .audit-textarea {
            margin-top: 15px;
            width: 100%;
        }
        /* 操作列按钮间距 */
        .operate-btn {
            margin-right: 8px;
        }

        .btnAndTable{
            margin:0 auto;
            margin-left:50px;
        }
    </style>
</head>
<body>
    <div id="app" class="common-layout"
         data-sex-list="@sexListJson"
         data-stock-in-status-list="@stockInStatusListJson">
        <div id="tableBlock">
            <form>
                <table width="1700px" height="80px">
                    <tbody>
                        <tr style="background-color: #fff;">
                            <td height="40px" width="280px">
                                &nbsp;&nbsp;&nbsp;&nbsp<span>进货单号</span>&nbsp;&nbsp;&nbsp;&nbsp;
                                <el-input type="text" v-model="orderNoInput" id="orderNoInput" class="formTableInput" placeholder="请输入"></el-input>
                            </td>
                            <td height="40px" width="280px">
                                <span>单据状态</span>&nbsp;&nbsp;&nbsp;&nbsp;
                                <el-select v-model="selectedStatus"
                                           class="formTableSelect"
                                           placeholder="请选择单据状态">
                                    <el-option v-for="(status, index) in stockInStatusList"
                                               :key="index"
                                               :label="status.Name"
                                               :value="status.Code">
                                    </el-option>
                                </el-select>
                            </td>
                            <td height="40px" width="280px">
                                <span>供应商</span>&nbsp;&nbsp;&nbsp;&nbsp;
                                <el-select v-model="selectedSupplierId"
                                                                           class="formTableSelect"
                                           placeholder="请选择供应商"
                                           :filterable="true"
                                           clearable>
                                    <el-option v-for="(supplier, index) in supplierList"
                                               :key="index"
                                               :label="supplier.supplierName"
                                               :value="supplier.supplierId">
                                    </el-option>
                                </el-select>
                            </td>
                            <td height="40px" width="280px">
                                <span>进货日期</span>&nbsp;&nbsp;&nbsp;&nbsp;
                                <el-date-picker id="dateRangePicker"
                                                class="formTableInput"
                                                type="daterange"
                                                range-separator="至"
                                                start-placeholder="开始时间"
                                                end-placeholder="结束时间"
                                                :size="size"
                                                v-model="dateRange"></el-date-picker>
                            </td>
                            <td height="40px" width="160px">
                                <el-button type="reset" v-on:click="resetForm">重置</el-button>&nbsp;
                                <el-button type="primary" v-on:click="searchTable">查询</el-button>
                            </td>
                        </tr>
                    </tbody>
                </table>
            </form>
            <div class="btnAndTable">
                <div class="buttonBlock">
                    <el-button type="primary" v-on:click="addOrder">新增</el-button>&nbsp;
                    <el-button type="danger" v-on:click="deleteOrder">删除</el-button>&nbsp;
                    <el-button type="default" v-on:click="copyOrder">复制</el-button>&nbsp;
                    <el-button type="danger" v-on:click="openAuditModal">审核</el-button>&nbsp;
                    <el-button type="danger" v-on:click="closeOrder">关闭</el-button>&nbsp;
                    <el-button type="primary" v-on:click="openOrder">开启</el-button>&nbsp;
                    <el-button type="default" v-on:click="exportTable">导出</el-button>&nbsp;
                    <el-button type="success" v-on:click="refrushTable">刷新</el-button>&nbsp;
                </div>
                <!-- 表格操作列按状态动态显示按钮 -->
                <el-table :data="paginatedData"
                          style="width: 1600px; margin-top: 10px"
                          v-on:selection-change="handleSelectionChange"
                          ref="multipleTable"
                          stripe>
                    <!-- 其他列配置保持不变 -->
                    <el-table-column fixed type="selection" width="50"></el-table-column>
                    <el-table-column fixed label="货品编号" width="150">
                        <template #default="scope">
                            <span style="color: #10b981; cursor: pointer;" v-on:click="jumpToDetail(scope.row)">
                                {{ scope.row.upOrderNo }}
                            </span>
                        </template>
                    </el-table-column>
                    <el-table-column fixed
                                     prop="orderStatus"
                                     label="单据状态"
                                     width="100"
                                     :formatter="formatStatusColumn">
                    </el-table-column>

                    <!-- 进货日期列：只显示年月日 -->
                    <el-table-column fixed
                                     prop="buyerDate"
                                     label="进货日期"
                                     width="150"
                                     :formatter="formatDate">
                    </el-table-column>

                    <el-table-column prop="supplierName" label="供应商" width="120"></el-table-column>
                    <el-table-column prop="contactPerson" label="联系人" width="120"></el-table-column>
                    <el-table-column prop="contactPhone" label="联系方式" width="120"></el-table-column>
                    <el-table-column prop="buyerOrgName" label="进货部门" width="120"></el-table-column>
                    <el-table-column prop="buyerBy" label="进货人" width="120"></el-table-column>

                    <!-- 货品数量列：保留两位小数 -->
                    <el-table-column prop="allOrderQuantity"
                                     label="货品数量(吨)"
                                     width="120"
                                     :formatter="formatNumber">
                    </el-table-column>

                    <!-- 货品金额列：保留两位小数 -->
                    <el-table-column prop="purchaseUnitPriceCount"
                                     label="货品金额(元)"
                                     width="120"
                                     :formatter="formatNumber">
                    </el-table-column>

                    <!-- 进货货品列：最多显示7个文字，超出用“等”代替 -->
                    <el-table-column prop="allGoodsName"
                                     label="进货货品"
                                     width="120"
                                     :formatter="formatGoodsName">
                    </el-table-column>

                    <el-table-column prop="createBy" label="制单人" width="120"></el-table-column>
                    <el-table-column prop="createOrgName" label="所在部门" width="120"></el-table-column>

                    <!-- 制单时间列：只显示年月日 -->
                    <el-table-column prop="createTime"
                                     label="制单时间"
                                     width="120"
                                     :formatter="formatDate">
                    </el-table-column>

                    <el-table-column prop="auditorBy" label="审核人" width="120"></el-table-column>

                    <!-- 审核时间列：只显示年月日 -->
                    <el-table-column prop="auditorTime"
                                     label="审核时间"
                                     width="120"
                                     :formatter="formatDate">
                    </el-table-column>

                    <el-table-column fixed="right" label="操作" min-width="180">
                        <template #default="scope">
                            <!-- 1. 草稿/待审核 → 显示【编辑】【删除】 -->
                            <el-button v-if="getStatusText(scope.row.orderStatus) === '草稿' || getStatusText(scope.row.orderStatus) === '待审核'"
                                       class="operate-btn"
                                       link type="primary" size="default"
                                       v-on:click="handleEdit(scope.row)">
                                编辑
                            </el-button>
                            <el-button v-if="getStatusText(scope.row.orderStatus) === '草稿' || getStatusText(scope.row.orderStatus) === '待审核'"
                                       class="operate-btn"
                                       link type="danger" size="default"
                                       v-on:click="deleteSingleOrder(scope.row)">
                                删除
                            </el-button>

                            <!-- 2. 已驳回 → 显示【编辑】【撤销】 -->
                            <el-button v-if="getStatusText(scope.row.orderStatus) === '驳回'"
                                       class="operate-btn"
                                       link type="primary" size="default"
                                       v-on:click="handleEdit(scope.row)">
                                编辑
                            </el-button>
                            <el-button v-if="getStatusText(scope.row.orderStatus) === '驳回'"
                                       class="operate-btn"
                                       link type="warning" size="default"
                                       v-on:click="handleRejectCancel(scope.row)">
                                撤销
                            </el-button>

                            <!-- 3. 未入库 → 显示【撤销】 -->
                            <el-button v-if="getStatusText(scope.row.orderStatus) === '未入库'"
                                       class="operate-btn"
                                       link type="warning" size="default"
                                       v-on:click="handleRejectCancel(scope.row)">
                                撤销
                            </el-button>

                            <!-- 4. 部分入库/已完成 → 无按钮 -->
                            <span v-if="getStatusText(scope.row.orderStatus) === '部分入库' || getStatusText(scope.row.orderStatus) === '已完成'">
                                -
                            </span>
                        </template>
                    </el-table-column>
                </el-table>
            </div>
            <div class="pagination-container">
                <el-pagination v-model:current-page="currentPage"
                               v-model:page-size="pageSize"
                               :page-sizes="[10, 20, 50, 100]"
                               :total="total"
                               layout="total, sizes, prev, pager, next, jumper"
                               v-on:size-change="handleSizeChange"
                               v-on:current-change="handleCurrentChange">
                </el-pagination>
            </div>
        </div>
        <!-- 审核模态框 -->
        <el-dialog title="订单审核"
                   v-model="isAuditModalOpen"
                   width="500px"
                   :before-close="handleAuditModalClose">
            <div class="audit-content">
                <el-radio-group v-model="selectedAuditResult" required>
                    <el-radio label="pass">通过</el-radio>
                    <el-radio label="reject">驳回</el-radio>
                </el-radio-group>
                <el-input class="audit-textarea"
                          type="textarea"
                          v-model="auditOpinion"
                          placeholder="请输入审核意见（驳回时必填）"
                          :rows="4"
                          :maxlength="200"
                          show-word-limit></el-input>
            </div>
            <template #footer>
                <el-button v-on:click="isAuditModalOpen = false">取消</el-button>
                <el-button type="primary" v-on:click="confirmAudit">确认审核</el-button>
            </template>
        </el-dialog>
    </div>

    <script>
        const { createApp, ref, onMounted, computed } = Vue;
        const { ElMessageBox, ElMessage, ElNotification} = ElementPlus;
        const app = createApp({
            setup() {
                // -------------------------- 1. 基础数据初始化 --------------------------
                // 状态字典解析
                const stockInStatusListStr = document.getElementById('app').dataset.stockInStatusList || '[]';
                const stockInStatusList = ref([]);
                try {
                    const parseData = JSON.parse(stockInStatusListStr);
                    stockInStatusList.value = Array.isArray(parseData) ? parseData : [];
                } catch (e) {
                    console.error('解析单据状态字典失败：', e);
                    stockInStatusList.value = [];
                }

                //获取登录人Id
                const getCurrentUserId = () => {
                    // 1. 从 sessionStorage 读取存储的 user JSON 字符串
                    const userStr = sessionStorage.getItem('YH');
                    if (!userStr) {
                        ElMessage.warning('未检测到登录状态，请重新登录');
                        return '';
                    }

                    try {
                        // 2. 解析 JSON 字符串为对象
                        const userObj = JSON.parse(userStr);
                        // 3. 提取 usersId（兼容可能的空值）
                        const userId = userObj?.id?.toString() || '';

                        if (!userId) {
                            ElMessage.warning('用户信息不完整，请重新登录');
                        }
                        return userId;
                    } catch (error) {
                        // 处理 JSON 解析失败的异常（如格式错误）
                        console.error('解析用户信息失败：', error);
                        ElMessage.error('用户信息异常，请重新登录');
                        return '';
                    }
                };

                //当前登录用户Id
                const currentUserId = ref(getCurrentUserId());

                // 表格数据（新增草稿/部分入库/已完成状态，补充完整字段）
                const tableData = ref([
                    {
                        upOrderId: 0, // 对应 long 类型，前端用 number
                        upOrderNo: '', // 对应 string 类型
                        orderStatus: '', // 对应 string 类型
                        buyerDate: null, // 对应 DateTime 类型，前端可用 Date 对象或字符串
                        supplierName: '', // 对应 string 类型
                        contactPerson: '', // 对应 string 类型
                        contactPhone: '', // 对应 string 类型
                        buyerOrgName: '', // 对应 string 类型
                        buyerBy: '', // 对应 string 类型
                        allOrderQuantity: 0, // 对应 decimal 类型，前端用 number
                        purchaseUnitPriceCount: 0, // 对应 decimal 类型，前端用 number
                        allGoodsName: '', // 对应 string 类型（聚合后的商品名）
                        createBy: '', // 对应 string 类型
                        createOrgName: '', // 对应 string 类型
                        createTime: null, // 对应 DateTime 类型
                        auditorBy: '', // 对应 string 类型
                        auditorTime: null // 对应 DateTime 类型（可能为 null，如未审核）
                    }
                ]);
                //日期
                const dateRange = ref([]);
                //进货单号
                const orderNoInput =ref('');
                
                const getStatusText = (statusCode) => {
                    const code = Number(statusCode);
                    const matchedStatus = stockInStatusList.value.find(item => Number(item.Code) === code);
                    return matchedStatus ? matchedStatus.Name : "未知状态";
                };

                const formatStatusColumn = (row, column, cellValue) => {
                    return getStatusText(cellValue);
                };


                function getPurchaseOrderData(){
                    axios.get('/StockUpOrder/GetAllOmPurchaseOrder')
                    .then(res=>{
                        tableData.value = res.data
                    })
                    .catch(err=>{
                        console.error('获取进货订单数据失败：', err);
                    });
                }

                // 选中行数据
                const selectedRows = ref([]);
                // 表格实例
                const multipleTable = ref(null);
                // 订单原始状态记录（用于开启时恢复）
                const orderOriginalStatus = ref({});

                // 格式化数字：保留两位小数
                const formatNumber = (row, column, cellValue) => {
                    // 处理空值或非数字情况
                    if (cellValue === null || cellValue === undefined || isNaN(Number(cellValue))) {
                        return '0.00';
                    }
                    // 保留两位小数
                    return Number(cellValue).toFixed(2);
                };

                // 格式化货品名称：最多显示7个字符，超出用“等”代替
                const formatGoodsName = (row, column, cellValue) => {
                    if (!cellValue) return '';
                    const str = String(cellValue);
                    // 中文算1个字符，英文/数字算1个字符（按常规视觉长度处理）
                    if (str.length <= 7) {
                        return str;
                    }
                    return str.substring(0, 7) + '...等其他货品';
                };

                const formatDate = (row, column, cellValue) => {
                    // 1. 显式处理 null/undefined/空字符串，直接返回空白
                    if (cellValue === null || cellValue === undefined || cellValue === '') {
                        return '';
                    }
                    let date;
                    // 2. 处理 Date 对象
                    if (cellValue instanceof Date) {
                        date = cellValue;
                    }
                    // 3. 处理字符串类型（包括 ISO 格式如 "2025-10-23T12:00:00" 或普通日期字符串）
                    else if (typeof cellValue === 'string') {
                        // 清除 ISO 字符串中的时间部分（如 "2025-10-23T12:00:00" → "2025-10-23"）
                        const pureDateStr = cellValue.replace(/T.*/, '').trim();
                        // 若处理后为空，返回空白
                        if (!pureDateStr) return '';
                        if (pureDateStr === '0001-01-01') {
                            return '';
                        }
                        date = new Date(pureDateStr);
                    }
                    // 4. 其他类型（如数字时间戳），直接转为 Date
                    else {
                        date = new Date(cellValue);
                    }
                    // 5. 校验日期是否有效（避免 Invalid Date 导致的 NaN 问题）
                    if (isNaN(date.getTime())) {
                        return ''; // 无效日期返回空白
                    }
                    // 6. 正常格式化年月日（补零确保格式统一，如 1月 → 01月）
                    const year = date.getFullYear();
                    const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从 0 开始，需 +1
                    const day = String(date.getDate()).padStart(2, '0');
                    return `${year}-${month}-${day}`;
                };


                // -------------------------- 供应商树形选择相关 --------------------------
                // 1. 普通供应商列表（平级数据，用于下拉选择）
                const supplierList = ref([]);
                // 2. 绑定选中的供应商ID（与查询参数关联，复用原有变量名，避免修改查询逻辑）
                const selectedSupplierId = ref('');

                // 3. 加载普通供应商列表（调用后端平级数据接口）
                const loadSupplierList = async () => {
                    try {
                        // 调用后端获取平级供应商列表接口（返回格式：[{supplierId, supplierName, ...}]）
                        const res = await axios.get('/StockUpOrder/GetSupplierInfoForSelectTable');
                        if (Array.isArray(res.data)) {
                            supplierList.value = res.data; // 直接使用平级数据
                        } else {
                            ElMessage.warning('供应商数据格式异常');
                            supplierList.value = [];
                        }
                    } catch (err) {
                        console.error('加载供应商列表失败：', err);
                        ElMessage.error('网络错误，无法加载供应商数据');
                        supplierList.value = [];
                    }
                };


                // -------------------------- 2. 分页逻辑 --------------------------
                const currentPage = ref(1);
                const pageSize = ref(10);
                const total = computed(() => tableData.value.length);
                const paginatedData = computed(() => {
                    const start = (currentPage.value - 1) * pageSize.value;
                    const end = start + pageSize.value;
                    return tableData.value.slice(start, end);
                });

                const handleSizeChange = (val) => {
                    pageSize.value = val;
                    currentPage.value = 1;
                };

                const handleCurrentChange = (val) => {
                    currentPage.value = val;
                    if (multipleTable.value) {
                        multipleTable.value.clearSelection();
                        selectedRows.value = [];
                    }
                };


                // -------------------------- 3. 审核模态框相关 --------------------------
                const isAuditModalOpen = ref(false);
                const selectedAuditResult = ref('');
                const auditOpinion = ref('');
                const canAuditRows = ref([]);

                // 打开审核模态框
                const openAuditModal = () => {
                    if (selectedRows.value.length === 0) {
                        ElMessage({ type: 'warning', message: '请先选中需要审核的订单！' });
                        return;
                    }
                    // 仅待审核状态可审核
                    canAuditRows.value = selectedRows.value.filter(row => row.orderStatus === '1');
                    if (canAuditRows.value.length === 0) {
                        ElMessage({ type: 'error', message: '选中的订单中无「待审核」状态订单！' });
                        return;
                    }
                    selectedAuditResult.value = '';
                    auditOpinion.value = '';
                    isAuditModalOpen.value = true;
                };

                // 关闭审核模态框
                const handleAuditModalClose = () => {
                    selectedAuditResult.value = '';
                    auditOpinion.value = '';
                    isAuditModalOpen.value = false;
                };

                // 确认审核（通过→未入库，驳回→已驳回）
                const confirmAudit = () => {
                    if (!selectedAuditResult.value) {
                        ElMessage({ type: 'warning', message: '请选择审核结果（通过/驳回）！' });
                        return;
                    }
                    if (selectedAuditResult.value === 'reject' && !auditOpinion.value.trim()) {
                        ElMessage({ type: 'warning', message: '驳回订单时必须填写审核意见！' });
                        return;
                    }

                    // 1. 确定目标状态码（通过→3，驳回→2）
                    const targetStatusCode = selectedAuditResult.value === 'pass' ? '3' : '2';
                    // 2. 获取审核人ID（当前登录用户）
                    const auditorBy = currentUserId.value;
                    if (!auditorBy) {
                        ElMessage({ type: 'error', message: '未获取到审核人信息，请重新登录！' });
                        return;
                    }

                    ElMessageBox.confirm(
                        `确定${selectedAuditResult.value === 'pass' ? '通过' : '驳回'}选中的 ${canAuditRows.value.length} 条订单吗？`,
                        '确认审核',
                        { type: selectedAuditResult.value === 'pass' ? 'info' : 'warning' }
                    ).then(async () => {
                        try {
                            // 3. 批量审核订单（循环调用审核接口）
                            for (const row of canAuditRows.value) {
                                const response = await axios.post(
                                    '/StockUpOrder/AuditOmPurOrder',
                                    {
                                        auditorBy: Number(auditorBy), // 与后端 AuditorBy 匹配
                                        auditorComment: auditOpinion.value.trim() || '', // 与后端 AuditorComment 匹配
                                        statu: targetStatusCode, // 与后端 Statu 匹配
                                        upOrderId: row.upOrderId // 与后端 UpOrderId 匹配
                                    },
                                    { headers: { 'Content-Type': 'application/json' } } // 明确 JSON 格式
                                );

                                // 处理单个订单审核失败的情况
                                if (!response.data>0) {
                                    throw new Error(`订单 ${row.upOrderNo} 审核失败：${response.data?.message || '未知错误'}`);
                                }
                            }

                            // 4. 审核成功后的处理
                            ElMessage({
                                type: 'success',
                                message: `订单${selectedAuditResult.value === 'pass' ? '审核通过（已转为未入库）' : '审核驳回'}成功！`
                            });

                            // 5. 清空选择并关闭模态框
                            if (multipleTable.value) {
                                multipleTable.value.clearSelection();
                                selectedRows.value = [];
                            }
                            handleAuditModalClose();

                            // 6. 重新拉取数据，确保前端状态与后端一致
                            getPurchaseOrderData();

                        } catch (error) {
                            // 处理审核过程中的异常（网络错误或单个订单审核失败）
                            ElMessage({
                                type: 'error',
                                message: error.message || '审核过程中发生错误，请重试！'
                            });
                        }
                    }).catch(() => {
                        ElMessage({ type: 'info', message: '已取消审核' });
                    });
                };

                //改变订单状态
                async function changeOrderStatu(statuValue, upOrderId, updateBy) {
                    // 1. 基础校验
                    if (!statuValue || !upOrderId || upOrderId <= 0 || !updateBy) {
                        ElMessage({ type: 'error', message: '订单ID、状态值或修改人ID不能为空！' });
                        return;
                    }

                    // 2. 构建请求体（区分是否有审核意见）
                    const requestBody = {
                        statu: statuValue,
                        upOrderId: upOrderId,
                        updateBy: updateBy
                    };

                    try {
                        // 3. 发送POST请求
                        const res = await axios.post(
                            '/StockUpOrder/ChangeOmPurOrderStatu',
                            requestBody, // 请求体（含审核意见或仅状态+ID+修改人ID）
                            { headers: { 'Content-Type': 'application/json' } } // 请求头
                        );

                        // 4. 处理响应（假设后端返回 { success: boolean, message: string }）
                        if (res.data>0) {
                            ElMessage.success(res.data.message || '订单状态修改成功！');
                        } else {
                            ElMessage.error(res.data?.message || '订单状态修改失败，请重试！');
                        }
                    } catch (err) {
                        // 5. 捕获网络异常
                        console.error('修改订单状态失败：', err);
                        ElMessage.error('网络错误，无法连接服务器，请检查网络后重试！');
                    }
                }


                // -------------------------- 4. 核心操作方法（按状态控制权限） --------------------------
                // 4.1 选中行变化
                const handleSelectionChange = (val) => {
                    selectedRows.value = val;
                };

                // 4.2 编辑（仅草稿/待审核/已驳回可执行）
                const handleEdit = (row) => {
                    // 二次校验状态（避免绕过前端DOM操作），用数字码判断
                    const allowEditStatusCodes = [0, 1, 2]; // 草稿(0)、待审核(1)、已驳回(2)
                    const rowStatusCode = Number(row.orderStatus);
                    if (!allowEditStatusCodes.includes(rowStatusCode)) {
                        ElMessage({ type: 'error', message: `当前「${getStatusText(row.orderStatus)}」状态不允许编辑！` });
                        return;
                    }
                    window.location.href=`/StockUpOrder/UpdateIndex?id=${row.upOrderId}`;
                    // 实际项目跳转：window.location.href = `/StockIn/Edit?id=${row.upOrderId}`;
                };

                // 4.3 单行删除（仅草稿/待审核可执行）
                const deleteSingleOrder = (row) => {
                    // 1. 二次校验状态（草稿0/待审核1）
                    const allowDeleteStatusCodes = [0, 1];
                    const rowStatusCode = Number(row.orderStatus);
                    if (!allowDeleteStatusCodes.includes(rowStatusCode)) {
                        ElMessage({
                            type: 'error',
                            message: `当前「${getStatusText(row.orderStatus)}」状态不允许删除！`
                        });
                        return;
                    }

                    // 2. 获取当前登录人ID（修改人）
                    const updateBy = currentUserId.value;
                    if (!updateBy) {
                        ElMessage({ type: 'error', message: '未获取到用户信息，请重新登录！' });
                        return;
                    }

                    ElMessageBox.confirm(
                        `确定删除订单 ${row.upOrderNo || row.upOrderId} 吗？删除后不可恢复！`,
                        '警告',
                        { type: 'error' }
                    ).then(async () => {
                        try {
                            // 3. 调用后端删除接口（单个订单ID用数组包裹，匹配批量接口参数）
                            const response = await axios.post(
                                '/StockUpOrder/DeleteOmPurOrder',
                                {
                                    ids: [Number(row.upOrderId)], // 单个ID转为数组
                                    updateBy: Number(updateBy)   // 传入修改人
                                },
                                { headers: { 'Content-Type': 'application/json' } }
                            );

                            // 4. 处理响应
                            if (response.data > 0) {
                                ElMessage({ type: 'success', message: '订单删除成功！' });
                                // 重新拉取数据，确保状态一致
                                getPurchaseOrderData();
                            } else {
                                ElMessage({ type: 'error', message: '订单删除失败，请重试！' });
                            }
                        } catch (error) {
                            console.error('单个删除订单失败：', error);
                            ElMessage({ type: 'error', message: '网络错误或删除异常，请稍后重试！' });
                        }
                    }).catch(() => {
                        ElMessage({ type: 'info', message: '已取消删除' });
                    });
                };

                // 4.4 撤销操作（仅已驳回/未入库可执行）
                const handleRejectCancel = (row) => {
                    // 1. 二次校验状态，用数字码判断
                    const allowRejectCancelStatusCodes = [2, 3]; // 已驳回(2)、未入库(3)
                    const rowStatusCode = Number(row.orderStatus);
                    if (!allowRejectCancelStatusCodes.includes(rowStatusCode)) {
                        ElMessage({
                            type: 'error',
                            message: `当前「${getStatusText(row.orderStatus)}」状态不允许撤销！`
                        });
                        return;
                    }

                    // 2. 确定目标状态（回退到待审核(1)）
                    const targetStatusCode = '1';
                    // 3. 获取当前登录人ID（修改人）
                    const updateBy = currentUserId.value;
                    if (!updateBy) {
                        ElMessage({ type: 'error', message: '未获取到用户信息，请重新登录！' });
                        return;
                    }

                    // 4. 确认撤销操作
                    ElMessageBox.confirm(
                        `确定撤销${getStatusText(row.orderStatus)}状态，将订单${row.upOrderNo || row.upOrderId}恢复为「待审核」吗？`,
                        '确认撤销',
                        { type: 'warning' }
                    ).then(async () => {
                        try {
                            // 5. 调用后端接口修改状态
                            const response = await axios.post(
                                '/StockUpOrder/ChangeOmPurOrderStatu',
                                {
                                    statu: targetStatusCode,
                                    upOrderId: row.upOrderId,
                                    updateBy: Number(updateBy) // 转换为数字类型，匹配后端long
                                },
                                { headers: { 'Content-Type': 'application/json' } }
                            );

                            // 6. 处理接口响应
                            if (response.data>0) {
                                // 前端更新状态
                                row.orderStatus = targetStatusCode;
                                ElMessage({
                                    type: 'success',
                                    message: '撤销成功，已恢复为待审核状态！'
                                });
                                // 重新拉取数据确保一致性
                                getPurchaseOrderData();
                            } else {
                                ElMessage({
                                    type: 'error',
                                    message: response.data?.message || '撤销失败，请重试！'
                                });
                            }
                        } catch (error) {
                            console.error('撤销操作失败：', error);
                            ElMessage({
                                type: 'error',
                                message: '网络错误，无法完成撤销操作！'
                            });
                        }
                    }).catch(() => {
                        ElMessage({ type: 'info', message: '已取消撤销' });
                    });
                };

                // 4.5 批量删除（仅草稿/待审核可执行）
                const deleteOrder = () => {
                    if (selectedRows.value.length === 0) {
                        ElMessage({ type: 'warning', message: '请先选中需要删除的订单！' });
                        return;
                    }

                    // 1. 筛选可删除的订单（状态：草稿0/待审核1）
                    const canDeleteRows = selectedRows.value.filter(row => {
                        const rowStatusCode = Number(row.orderStatus);
                        return rowStatusCode === 0 || rowStatusCode === 1;
                    });
                    if (canDeleteRows.length === 0) {
                        ElMessage({ type: 'error', message: '仅「草稿」或「待审核」状态的订单可删除！' });
                        return;
                    }

                    // 2. 获取当前登录人ID（修改人）
                    const updateBy = currentUserId.value;
                    if (!updateBy) {
                        ElMessage({ type: 'error', message: '未获取到用户信息，请重新登录！' });
                        return;
                    }

                    // 3. 提取订单ID列表（转为number类型，匹配后端long）
                    const deleteIds = canDeleteRows.map(row => Number(row.upOrderId));

                    ElMessageBox.confirm(
                        `确定删除选中的 ${canDeleteRows.length} 条订单吗？删除后不可恢复！`,
                        '警告',
                        { type: 'error' }
                    ).then(async () => {
                        try {
                            // 4. 调用后端批量删除接口
                            const response = await axios.post(
                                '/StockUpOrder/DeleteOmPurOrder',
                                { ids: deleteIds, updateBy: Number(updateBy) }, // 传订单ID列表和修改人
                                { headers: { 'Content-Type': 'application/json' } }
                            );

                            // 5. 处理接口响应（后端返回删除成功的数量）
                            if (response.data > 0) {
                                ElMessage({ type: 'success', message: `成功删除 ${response.data} 条订单！` });
                                // 重新拉取数据，确保前端与后端一致
                                getPurchaseOrderData();
                                // 清空选中状态
                                if (multipleTable.value) {
                                    multipleTable.value.clearSelection();
                                }
                                selectedRows.value = [];
                            } else {
                                ElMessage({ type: 'error', message: '删除失败，无符合条件的订单！' });
                            }
                        } catch (error) {
                            console.error('批量删除订单失败：', error);
                            ElMessage({ type: 'error', message: '网络错误或删除异常，请稍后重试！' });
                        }
                    }).catch(() => {
                        ElMessage({ type: 'info', message: '已取消删除' });
                    });
                };

                // 4.6 关闭订单（仅草稿/待审核/已驳回可执行）
                const closeOrder = () => {
                    if (selectedRows.value.length === 0) {
                        ElMessage({ type: 'warning', message: '请先选中需要关闭的订单！' });
                        return;
                    }

                    // 筛选可关闭的订单（状态码：0=草稿，1=待审核，2=已驳回）
                    const canCloseRows = selectedRows.value.filter(row => {
                        const rowStatusCode = Number(row.orderStatus);
                        return [0, 1, 2].includes(rowStatusCode);
                    });
                    if (canCloseRows.length === 0) {
                        ElMessage({ type: 'error', message: '仅「草稿」、「待审核」或「已驳回」的订单可关闭！' });
                        return;
                    }

                    ElMessageBox.confirm(
                        `确定关闭选中的 ${canCloseRows.length} 条订单吗？`,
                        '警告',
                        { type: 'error' }
                    ).then(async () => {
                        try {
                            const updateBy = currentUserId.value;
                            if (!updateBy) {
                                ElMessage({ type: 'error', message: '未获取到用户信息，请重新登录！' });
                                return;
                            }

                            // 批量关闭订单：串行调用接口，确保状态记录准确
                            for (const row of canCloseRows) {
                                // 1. 调用接口关闭订单
                                const response = await axios.post(
                                    '/StockUpOrder/ChangeOmPurOrderStatu',
                                    {
                                        statu: '6', // 6=已关闭
                                        upOrderId: row.upOrderId,
                                        updateBy: Number(updateBy)
                                    },
                                    { headers: { 'Content-Type': 'application/json' } }
                                );

                                // 2. 接口调用成功后，记录订单原始状态（关键：此时状态未被前端修改，是真实的关闭前状态）
                                if (response.data > 0) {
                                    orderOriginalStatus.value[row.upOrderId] = row.orderStatus; // 存储原始状态（如1=待审核）
                                    // 前端临时更新为“已关闭”
                                    row.orderStatus = '6';
                                } else {
                                    throw new Error(`订单 ${row.upOrderNo || row.upOrderId} 关闭失败，请重试！`);
                                }
                            }

                            // 关闭成功后的处理
                            ElMessage({ type: 'success', message: '订单关闭成功！' });
                            if (multipleTable.value) {
                                multipleTable.value.clearSelection();
                            }
                            selectedRows.value = [];
                            getPurchaseOrderData(); // 重新拉取数据，确保状态一致

                        } catch (error) {
                            console.error('关闭订单失败：', error);
                            ElMessage({ type: 'error', message: error.message || '关闭订单时发生错误！' });
                        }
                    }).catch(() => {
                        ElMessage({ type: 'info', message: '已取消关闭' });
                    });
                };

                // 4.7 开启订单（仅已关闭可执行，恢复原始状态）
                const openOrder = () => {
                    if (selectedRows.value.length === 0) {
                        ElMessage({ type: 'warning', message: '请先选中需要开启的订单！' });
                        return;
                    }

                    // 1. 筛选可开启的订单（仅已关闭：状态码6）
                    const canOpenRows = selectedRows.value.filter(row => Number(row.orderStatus) === 6);
                    if (canOpenRows.length === 0) {
                        ElMessage({ type: 'error', message: '选中的订单中无「已关闭」状态订单！' });
                        return;
                    }

                    // 2. 筛选有原始状态记录的订单（核心：排除无记录的异常订单）
                    const validOpenRows = canOpenRows.filter(row => {
                        const hasOriginalStatus = orderOriginalStatus.value[row.upOrderId] !== undefined;
                        if (!hasOriginalStatus) {
                            console.warn(`订单 ${row.upOrderNo || row.upOrderId} 原始状态缺失，无法自动恢复`);
                        }
                        return hasOriginalStatus;
                    });
                    if (validOpenRows.length === 0) {
                        ElMessage({
                            type: 'error',
                            message: '所有选中订单的原始状态均缺失，无法开启！建议刷新页面后重试。'
                        });
                        return;
                    }

                    // 3. 确认开启操作（提示用户部分订单可能无法开启）
                    const confirmMsg = validOpenRows.length < canOpenRows.length
                        ? `有 ${canOpenRows.length - validOpenRows.length} 条订单原始状态缺失，仅开启 ${validOpenRows.length} 条订单？`
                        : `确定开启选中的 ${validOpenRows.length} 条订单吗？开启后将恢复至关闭前状态`;

                    ElMessageBox.confirm(confirmMsg, '提示', { type: 'info' })
                        .then(async () => {
                            try {
                                const updateBy = currentUserId.value;
                                if (!updateBy) {
                                    ElMessage({ type: 'error', message: '未获取到用户信息，请重新登录！' });
                                    return;
                                }

                                // 4. 批量开启订单：串行调用接口，确保状态恢复准确
                                for (const row of validOpenRows) {
                                    // 获取关闭前的原始状态（如1=待审核）
                                    const originalStatusCode = orderOriginalStatus.value[row.upOrderId];

                                    // 调用接口恢复状态
                                    const response = await axios.post(
                                        '/StockUpOrder/ChangeOmPurOrderStatu',
                                        {
                                            statu: originalStatusCode, // 恢复为关闭前的原始状态
                                            upOrderId: row.upOrderId,
                                            updateBy: Number(updateBy)
                                        },
                                        { headers: { 'Content-Type': 'application/json' } }
                                    );

                                    if (response.data > 0) {
                                        // 接口成功后：更新前端状态 + 删除已恢复的原始状态记录
                                        row.orderStatus = originalStatusCode;
                                        delete orderOriginalStatus.value[row.upOrderId];
                                    } else {
                                        throw new Error(`订单 ${row.upOrderNo || row.upOrderId} 开启失败，请重试！`);
                                    }
                                }

                                // 5. 开启成功后的处理
                                ElMessage({ type: 'success', message: `成功开启 ${validOpenRows.length} 条订单！` });
                                if (multipleTable.value) {
                                    multipleTable.value.clearSelection();
                                }
                                selectedRows.value = [];
                                getPurchaseOrderData(); // 重新拉取数据，确保与后端一致

                            } catch (error) {
                                console.error('开启订单失败：', error);
                                ElMessage({ type: 'error', message: error.message || '开启订单时发生错误！' });
                            }
                        })
                        .catch(() => {
                            ElMessage({ type: 'info', message: '已取消开启' });
                        });
                };

                // -------------------------- 5. 其他辅助方法 --------------------------
                // 导出
                const exportTable = () => {
                    const orderNoInput = document.getElementById('orderNoInput');
                    const supplierInput = document.getElementById('supplierInput');
                    const datePicker = document.getElementById('dateRangePicker');

                    const orderNo = orderNoInput ? orderNoInput.value.trim() : '';
                    const supplier = supplierInput ? supplierInput.value.trim() : '';
                    const dateRange = datePicker && datePicker.value ? datePicker.value.join(',') : '';
                    const status = selectedStatus.value || '';

                    const exportUrl = `/api/StockIn/Export?` +
                        `orderNo=${encodeURIComponent(orderNo)}&` +
                        `supplier=${encodeURIComponent(supplier)}&` +
                        `status=${encodeURIComponent(status)}&` +
                        `dateRange=${encodeURIComponent(dateRange)}`;

                    const link = document.createElement('a');
                    link.href = exportUrl;
                    link.download = `进货订单列表_${new Date().toLocaleDateString()}.xlsx`;
                    link.click();

                    ElMessage({ type: 'success', message: '导出请求已触发，正在下载...' });
                };

                // 刷新
                const refrushTable = () => {
                    // 1. 清空表格选择状态
                    if (multipleTable.value) {
                        multipleTable.value.clearSelection();
                        selectedRows.value = [];
                    }
                    // 2. 重置页码为第一页
                    currentPage.value = 1;

                    // 3. 显示加载中提示
                    ElMessage({ type: 'info', message: '正在刷新数据，请稍候...' });

                    // 4. 重新拉取最新数据（复用查询数据的核心方法）
                    getPurchaseOrderData()
                        .then(() => {
                            // 5. 刷新成功提示
                            ElMessage({ type: 'success', message: '表格已刷新，数据为最新状态！' });
                        })
                        .catch(() => {
                            // 6. 刷新失败提示
                            ElMessage({ type: 'error', message: '刷新失败，请检查网络后重试！' });
                        });
                };

                // 重置表单
                const resetForm = () => {
                    // 1. 清空进货单号输入框（保留 DOM 操作）
                    orderNoInput.value = '';
                    // 2. 关键：重置日期选择器的响应式变量（清空选中值）
                    dateRange.value = [];

                    // 3. 重置其他筛选条件
                    selectedStatus.value = '';
                    selectedSupplierId.value = '';
                };

                // 查询函数（改造后）
                const searchTable = () => {
                    // 1. 获取进货单号（保留 DOM 操作，兼容原有逻辑）
                    const orderNo = orderNoInput.value.trim()||'';
                    const status = selectedStatus.value || '';

                    // 2. 直接使用响应式变量获取日期值（daterange 类型返回 [开始日期, 结束日期] 数组）
                    const selectedDateRange = dateRange.value || [];

                    // 3. 构建请求参数（日期为空时设为 null，避免传空字符串给后端）
                    const requestParams = {
                        UpOrderNo: orderNo,
                        OrderStatus: status,
                        SupplierId: selectedSupplierId.value || 0,
                        // 从响应式变量中获取开始/结束日期，转为 ISO 格式
                        StartTime: selectedDateRange[0] ? new Date(selectedDateRange[0]).toISOString() : null,
                        EndTime: selectedDateRange[1] ? new Date(selectedDateRange[1]).toISOString() : null
                    };

                    axios.post('/StockUpOrder/SearchInfoBySmth', requestParams)
                        .then(res => {
                            tableData.value = res.data || [];
                            currentPage.value = 1;
                            ElMessage.success(`查询到 ${tableData.value.length} 条数据！`);
                        })
                        .catch(err => {
                            console.error('查询失败：', err);
                            ElMessage.error('查询失败，请重试！');
                    });
                };


                // 新增
                const addOrder = () => {
                    ElNotification({ title: '提示', message: '跳转至新增订单页面', type: 'info' });
                    window.location.href = '/StockUpOrder/AddIndex';
                };

                // 复制
                const copyOrder = () => {
                    if (selectedRows.value.length === 0) {
                        ElMessage({ type: 'warning', message: '请先选中需要复制的订单！' });
                        return;
                    }
                    if (selectedRows.value.length > 1) {
                        ElMessage({ type: 'warning', message: '仅支持单条订单复制！' });
                        return;
                    }
                    const targetRow = selectedRows.value[0];
                    if (targetRow.statu === '已关闭' || targetRow.statu === '部分入库' || targetRow.statu === '已完成') {
                        ElMessage({ type: 'error', message: '已关闭/部分入库/已完成的订单不支持复制！' });
                        return;
                    }
                    ElNotification({ title: '复制订单', message: `开始复制订单：${targetRow.id}`, type: 'info' });
                };

                // 批量撤销（仅未入库可执行）
                const cancleCheck = () => {
                    if (selectedRows.value.length === 0) {
                        ElMessage({ type: 'warning', message: '请先选中需要撤销审核的订单！' });
                        return;
                    }
                    // 仅未入库状态可批量撤销，未入库数字码是3
                    const canCancelRows = selectedRows.value.filter(row => Number(row.orderStatus) === 3);
                    if (canCancelRows.length === 0) {
                        ElMessage({ type: 'error', message: '选中的订单中无「未入库」状态订单！' });
                        return;
                    }
                    const cancelIds = canCancelRows.map(row => row.upOrderId).join(',');
                    ElMessageBox.confirm(`确定撤销 ${canCancelRows.length} 条订单的审核状态吗？`, '警告', { type: 'warning' })
                        .then(() => {
                            tableData.value.forEach(row => {
                                if (cancelIds.includes(row.upOrderId)) {
                                    row.orderStatus = 1; // 恢复为待审核（数字码1）
                                }
                            });
                            ElMessage({ type: 'success', message: '撤销审核成功！' });
                            selectedRows.value = [];
                        }).catch(() => ElMessage({ type: 'info', message: '已取消撤销' }));
                };

                //跳转进货订单详情页
                function jumpToDetail(row){
                    window.location.href=`/StockUpOrder/DetailIndex?upOrderId=${row.upOrderId}`;
                }


                // -------------------------- 6. 页面挂载 --------------------------
                onMounted(() => {
                    // if (stockInStatusList.value.length > 0) {
                    //     selectedStatus.value = stockInStatusList.value[0].Code;
                    // }
                    getPurchaseOrderData();
                    loadSupplierList();
                });

                // 筛选状态绑定
                const selectedStatus = ref('');

                // 暴露数据和方法
                return {
                    // 表格相关
                    tableData,
                    paginatedData,
                    selectedRows,
                    multipleTable,
                    handleSelectionChange,
                    handleEdit,
                    deleteSingleOrder,
                    handleRejectCancel,
                    //方法部分
                    getPurchaseOrderData,
                    getStatusText,
                    formatStatusColumn,
                    formatNumber,
                    formatGoodsName,
                    formatDate,

                    // 字典和筛选
                    stockInStatusList,
                    selectedStatus,

                    // 分页相关
                    currentPage,
                    pageSize,
                    total,
                    handleSizeChange,
                    handleCurrentChange,

                    // 审核模态框相关
                    isAuditModalOpen,
                    selectedAuditResult,
                    auditOpinion,
                    openAuditModal,
                    handleAuditModalClose,
                    confirmAudit,

                    // 按钮方法
                    addOrder,
                    deleteOrder,
                    copyOrder,
                    cancleCheck,
                    closeOrder,
                    openOrder,
                    exportTable,
                    refrushTable,
                    resetForm,
                    searchTable,
                    dateRange,
                    orderNoInput,
                    jumpToDetail,
                    // 新增：供应商树形选择相关
                    supplierList,
                    selectedSupplierId
                };
            }
        });
        app.use(ElementPlus, {
            locale: ElementPlusLocaleZhCn
        });
        app.mount('#app');
    </script>
</body>
</html>